# 匿名函数
"""
    使用lambda来创建匿名函数。

    lambda只是一个表达式，函数体比def简单很多。
    lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
    lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
"""

# lambda [arg1[, arg2, .....argn]]: 表达式
"""
    lambda 参数1, 参数2, ... : 表达式
    
    lambda 后跟参数列表（可多个，逗号分隔）
    : 后跟一个表达式（⚠️ 只能写一个表达式，不能写语句）
    表达式的结果自动作为返回值（不需要写 return）
"""

# lambda使用
sum = lambda x, y: x + y
print("lambda使用：",sum(1, 2))

# lambda与if
b = lambda x: "Even" if x % 2 == 0 else "Odd"
print("lambda与if：",b(10))

# lambda与for
l2 = [lambda: i for i in range(10)]
print("lambda与for-1：",[f() for f in l2])

l2 = [lambda x=i: x for i in range(10)]
print("lambda与for-2：",[f() for f in l2])

# 等效的 def 写法（帮助理解）
def make_func(n):
    def f():
        return n
    return f
l2 = [make_func(i) for i in range(10)]

# lambda与map
# 使用map进行两个列表相加
'''
    map(function, iterable, ...)
    
    function：一个函数（可以是普通函数、lambda、内置函数等）
    iterable：一个或多个可迭代对象（如 list, tuple, str, set, range 等）
    返回值：一个 map 对象（迭代器），不是列表！
    
    相当于：
    [function(item) for item in iterable]
    
    map() 返回的是惰性求值的迭代器，更省内存！
'''
# 总结：map(func, iterable) = “把函数 func 批量应用到 iterable 的每个元素上，返回一个惰性迭代器。
l1 = [1, 2, 3, 4]
l2 = [11, 22, 33, 44]
mm = list(map(lambda x, y: x + y, l1, l2))  # map() 会根据提供的函数对指定序列做映射。
print("lambda与map：",mm)

# lambda与内置函数
# 现有字典dic = {'a':1,'b':2,'c':23,'d':11,'e':4,'f':21}，请按照字段中的value进行排序？
"""
    sorted(iterable, *, key=None, reverse=False)
    参数说明：
    iterable 必填，任何可迭代对象（list, tuple, str, set, dict, generator 等）
    key 可选，指定一个函数，用于提取比较键（如按长度、按属性等）
    reverse 可选，True 为降序，False 为升序（默认）
"""
"""
    items() 是一个字典（dict）的方法，用于获取字典中所有的 键值对（key-value pairs），以可迭代的 (key, value) 元组形式返回。
    dict.items()
    返回类型：dict_items 对象（可迭代，类似视图）
    Python 3 中返回的是动态视图 —— 如果原字典改变，视图也会跟着变
    常配合 for 循环或 list() 使用
"""
# 用 dict(sorted(d.items())) 可以轻松按“键”排序字典，返回一个按键升序排列的新字典。
dic = {'a': 1, 'b': 2, 'c': 23, 'd': 11, 'e': 4, 'f': 21}
dic1 = sorted(dic.items(), key=lambda dic: dic[1])
dic2 = dict(sorted(dic.items(), reverse=False))
dic3 = dict(sorted(dic.items(), key=lambda dic: dic[1], reverse=False))
print("lambda与内置函数-1：",dic1)
print("lambda与内置函数-2：",dic2)
print("lambda与内置函数-3：",dic3)

## 使用filter进行序列筛选
"""
    filter(function, iterable)
    
    function：一个判断函数（返回 True/False），决定元素是否保留
    iterable：任何可迭代对象（如 list, tuple, str, set, range 等）
    返回值：一个 filter 对象（迭代器），不是列表！
"""
# 总结：filter(func, iterable) = “保留那些让 func(x) 返回 True 的元素，返回一个惰性迭代器
ll = [20, 30, 25, 40, 50]
print("filter筛选：", list(filter(lambda x: x > 25, ll)))

## 使用reduce，对所有元素进行累计操作
from functools import reduce
"""
    reduce() 是 Python 中一个函数式编程工具，用于对序列中的元素进行累积计算（如求和、求积、拼接等）。它不是内置函数（Python 3 中），需要从 functools 模块导入。
    from functools import reduce
    reduce(function, iterable[, initializer])
    参数说明：
    function    一个二元函数（接受两个参数）
    iterable    一个可迭代对象（如 list, tuple, str 等）
    initializer    可选，初始值（放在序列最前面参与计算）
"""
print("reduce-1：", reduce(lambda x, y: x + y, ll))

total = reduce(lambda x, y: x + y, ll, 10)  # 初始值=10
print("reduce-2：", total)  # 175 → 10 + 20 + 30 + 25 + 40 + 50

# lambda与max(找出字典中值最大的key）
"""
    1. 从可迭代对象中找最大值：
        max(iterable, *, key=None, default=None)
    2. 从多个参数中找最大值：
        max(arg1, arg2, *args, key=None)
        
    参数说明
        iterable：可迭代对象，如列表 [1,2,3]、元组、字符串等。
        arg1, arg2, ...：多个可比较的参数。
        key（可选）：指定一个函数，用于自定义比较方式（如按长度、按小写等）。
        default（可选）：当可迭代对象为空时返回的默认值（仅适用于可迭代对象形式）。
"""
price = {
    'a': 1,
    'b': 7,
    'c': 5,
    'd': 10,
    'e': 12,
    'f': 3
}
result = max(price, key=lambda x: price[x])
print("值最大的key-1：",result)

# max(d) 默认比较的是键（key）
# key=d.get 告诉 max()：按“值”比较，d.get(key) 返回对应的值
max_key = max(price, key=price.get)  # 推荐
print("值最大的key-2：",max_key)  # 输出: 'b'

# 键最大的值
max_key_value = price[max(price)]
print("键最大的值：",max_key_value)  # 15

# 找出字典中值最大的值
max_value = max(price.values())
print("最大的值：",max_value)  # 输出: 25

# 值最大的键值对
key = max(price, key=price.get)
result = {key: price[key]}
print(result)  # {'b': 25}